// 用户信息显示函数
document.addEventListener('DOMContentLoaded', function() {
    // 显示用户信息 - 添加错误处理，因为displayUserInfo是异步函数
    displayUserInfo().catch(error => {
        console.error('显示用户信息时发生未捕获的错误:', error);
    });
    
    // 绑定表单提交事件
    const addVehicleForm = document.getElementById('addVehicleForm');
    addVehicleForm.addEventListener('submit', function(e) {
        e.preventDefault();
        handleFormSubmit();
    });
    
    // 绑定退出按钮事件
    const logoutBtn = document.querySelector('.logout-btn');
    logoutBtn.addEventListener('click', handleLogout);
    
    // 设置默认时间（当前时间）
    const now = new Date();
    const formattedNow = now.toISOString().slice(0, 16);
    document.getElementById('available_start').value = formattedNow;
    
    // 设置默认结束时间（当前时间+7天）
    const endDate = new Date(now);
    endDate.setDate(endDate.getDate() + 7);
    const formattedEndDate = endDate.toISOString().slice(0, 16);
    document.getElementById('available_end').value = formattedEndDate;
});

// 后端API基础地址（前端运行在8000端口，后端通常在8080端口）
const API_BASE = window.API_BASE || 'http://localhost:8080';

/**
 * 获取用户信息
 * @param {string} token - 认证令牌
 */
async function fetchUserInfo(token) {
    console.log('使用令牌获取用户信息:', token);
    
    try {
        // 优先使用认证API获取用户信息（会携带Bearer令牌）
        if (window.api && window.api.auth && window.api.auth.getUserInfo) {
            const result = await window.api.auth.getUserInfo(token);
            if (result && result.success && result.userInfo) {
                console.log('从后端API获取的用户信息:', result.userInfo);
                return result.userInfo;
            }
            throw new Error(result?.message || '获取用户信息失败');
        }

        // 兜底：如果没有认证API，则直接通过通用API请求
        if (window.utils && window.utils.api && window.utils.api.get) {
            const headers = { 'Authorization': `Bearer ${token}` };
            const response = await window.utils.api.get('/api/auth/user/info', {}, { headers });
            if (response && response.status === 'success' && response.data) {
                return response.data;
            }
            throw new Error(response?.message || '获取用户信息失败');
        }

        // 最后兜底：使用fetch API直接调用
        const response = await fetch(`${API_BASE}/api/auth/user/info`, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${token}`
            },
            credentials: 'include'
        });
        
        if (!response.ok) {
            throw new Error(`服务器响应错误: ${response.status}`);
        }
        
        const result = await response.json();
        if (result.status === 'success' || result.success) {
            return result.data || result;
        }
        throw new Error(result.message || '获取用户信息失败');
        
    } catch (error) {
        console.error('获取用户信息失败:', error);
        // 尝试从令牌中提取基本信息作为备用方案
        try {
            const decodedToken = decodeToken(token);
            if (decodedToken && decodedToken.userId) {
                console.log('API获取用户信息失败，使用令牌中的用户ID作为备用方案');
                return {
                    userId: decodedToken.userId,
                    username: `用户${decodedToken.userId.substring(0, 4)}`,
                    isFallback: true
                };
            }
        } catch (tokenError) {
            console.error('解析令牌获取备用用户信息失败:', tokenError);
        }
        throw error;
    }
}

// 显示用户信息
async function displayUserInfo() {
    try {
        // 获取认证令牌
        const token = getAuthToken();
        
        // 如果没有令牌，提示登录
        if (!token) {
            console.log('未获取到认证令牌');
            const userSection = document.getElementById('userSection');
            userSection.innerHTML = '<div class="user-info"><span class="username">请先登录</span></div>';
            
            const submitBtn = document.querySelector('.submit-btn');
            if (submitBtn) {
                submitBtn.disabled = true;
                submitBtn.textContent = '请先登录';
            }
            
            // 检查是否有URL中的自动登录参数
            const urlParams = new URLSearchParams(window.location.search);
            const autoLogin = urlParams.get('autoLogin');
            
            // 弹出提示信息，引导用户登录
            setTimeout(() => {
                // 如果有autoLogin参数，则自动跳转到登录页
                if (autoLogin === 'true') {
                    const redirectUrl = encodeURIComponent('add-vehicle.html');
                    window.location.href = `./login.html?redirect=${redirectUrl}`;
                    return;
                }
                
                if (!confirm('您尚未登录，需要先登录才能添加车辆。是否前往登录页面？')) {
                    // 如果用户取消登录，停留在当前页面，但表单已禁用
                    console.log('用户选择不登录，停留在当前页面');
                } else {
                    // 如果用户确认登录，带上重定向参数跳转到登录页
                    const redirectUrl = encodeURIComponent('add-vehicle.html');
                    window.location.href = `./login.html?redirect=${redirectUrl}`;
                }
            }, 500);
            
            return;
        }
        
        console.log('获取到令牌，尝试获取用户信息...');
        
        try {
            // 调用API获取用户信息
            const userInfo = await fetchUserInfo(token);
            console.log('获取到用户信息:', userInfo);
            
            const userSection = document.getElementById('userSection');
            
            // 创建用户信息容器
            const userInfoContainer = document.createElement('div');
            userInfoContainer.className = 'user-info';
            
            // 创建用户头像
            const avatar = document.createElement('div');
            avatar.className = 'user-avatar';
            
            // 创建用户名显示
            const username = document.createElement('div');
            username.className = 'username';
            
            // 设置显示名称（优先使用昵称，然后是用户名，最后是默认值）
            const displayName = userInfo.nickname || userInfo.username || userInfo.realName || `用户${userInfo.userId?.substring(0, 4) || ''}`;
            
            // 设置头像文本和用户名
            avatar.textContent = displayName.charAt(0).toUpperCase();
            username.textContent = displayName;
            
            // 保存用户信息到localStorage，以便addVehicle函数能够正确获取ownerId
            const userInfoToSave = {
                id: userInfo.id || userInfo.userId,
                userId: userInfo.id || userInfo.userId,
                username: userInfo.username || userInfo.nickname || userInfo.realName,
                loginTime: new Date().toISOString()
            };
            localStorage.setItem('userInfo', JSON.stringify(userInfoToSave));
            console.log('已保存用户信息到localStorage');
            
            // 添加到用户区域
            userInfoContainer.appendChild(avatar);
            userInfoContainer.appendChild(username);
            userSection.appendChild(userInfoContainer);
            
        } catch (apiError) {
            console.error('API获取用户信息失败，但继续显示基本登录状态:', apiError);
            
            // 即使API获取失败，也要显示基本登录状态
            const userSection = document.getElementById('userSection');
            userSection.innerHTML = '<div class="user-info"><div class="user-avatar">U</div><div class="username">用户</div></div>';
            
            // 如果需要，可以给用户一个提示
            // alert('加载用户信息时遇到问题，但您仍可以继续操作');
        }
    } catch (error) {
        console.error('显示用户信息失败:', error);
        // 出错时也提供友好提示而不是直接重定向
        alert('加载用户信息时出错，请刷新页面重试或联系客服');
    }
}

// 处理表单提交函数
function handleFormSubmit() {
    try {
        const token = getAuthToken();
        if (!token) {
            // 如果没有令牌，提供友好提示而不是直接重定向
            alert('请先登录才能提交车辆信息');
            if (confirm('是否前往登录页面？')) {
                const redirectUrl = encodeURIComponent('add-vehicle.html');
                window.location.href = `./login.html?redirect=${redirectUrl}`;
            }
            return;
        }
        
        // 收集表单数据
        const formData = {
            brand: document.getElementById('brand').value,
            model: document.getElementById('model').value,
            color: document.getElementById('color').value,
            license_plate: document.getElementById('license_plate').value,
            daily_rate: parseFloat(document.getElementById('daily_rate').value),
            available_start: new Date(document.getElementById('available_start').value),
            available_end: new Date(document.getElementById('available_end').value),
            next_maintenance: document.getElementById('next_maintenance').value ? 
                new Date(document.getElementById('next_maintenance').value) : null,
            seat_count: parseInt(document.getElementById('seat_count').value),
            power_type: document.getElementById('power_type').value,
            mileage: parseFloat(document.getElementById('mileage').value),
            insurance_info: document.getElementById('insurance_info').value,
            status: 'available' // 默认可用状态
        };
        
        // 验证表单数据
        if (!validateFormData(formData)) {
            return;
        }
        
        // 发送请求到后端API添加车辆（这里使用模拟数据）
        addVehicle(formData, token)
            .then(response => {
                if (response.success) {
                    // 显示成功提示
                    alert(response.message || '车辆添加成功！');
                    window.location.href = './lender-dashboard.html';
                } else {
                    alert('添加失败：' + (response.message || '未知错误'));
                }
            })
            .catch(error => {
                console.error('添加车辆失败:', error);
                alert('添加失败，请稍后重试');
            });
    } catch (error) {
        console.error('提交表单时出错:', error);
        alert('提交失败，请稍后重试');
    }
}

// 验证表单数据
function validateFormData(formData) {
    // 检查必填字段
    if (!formData.brand || !formData.model || !formData.color || !formData.license_plate || 
        !formData.daily_rate || !formData.available_start || !formData.available_end || 
        !formData.seat_count || !formData.power_type || !formData.mileage) {
        alert('请填写所有必填字段');
        return false;
    }
    
    // 验证日租金
    if (formData.daily_rate < 0) {
        alert('日租金不能为负数');
        return false;
    }
    
    // 验证座位数
    if (formData.seat_count < 1 || formData.seat_count > 10) {
        alert('座位数应在1-10之间');
        return false;
    }
    
    // 验证里程数
    if (formData.mileage < 0) {
        alert('里程数不能为负数');
        return false;
    }
    
    // 验证时间范围
    if (formData.available_start >= formData.available_end) {
        alert('可用开始时间必须早于结束时间');
        return false;
    }
    
    return true;
}

// 添加车辆API调用函数
async function addVehicle(vehicleData, token) {
    try {
        // 检查令牌是否有效
        if (!token) {
            console.error('未获取到认证令牌');
            throw new Error('未获取到认证令牌，请重新登录');
        }
        
        // 日期格式化为后端期望的 'yyyy-MM-dd HH:mm:ss'（不含毫秒与Z）
        const formatDate = (dateObj) => {
            if (!dateObj) return null;
            const pad = (n) => (n < 10 ? '0' + n : '' + n);
            const y = dateObj.getFullYear();
            const M = pad(dateObj.getMonth() + 1);
            const d = pad(dateObj.getDate());
            const h = pad(dateObj.getHours());
            const m = pad(dateObj.getMinutes());
            const s = pad(dateObj.getSeconds());
            return `${y}-${M}-${d} ${h}:${m}:${s}`;
        };

        // 从当前登录用户获取ownerId
        let ownerId = 1; // 默认值
        try {
            const userInfo = localStorage.getItem('userInfo');
            if (userInfo) {
                const parsedUserInfo = JSON.parse(userInfo);
                // 检查用户信息中是否有id字段
                if (parsedUserInfo.id) {
                    ownerId = parsedUserInfo.id;
                } else if (parsedUserInfo.userId) {
                    ownerId = parsedUserInfo.userId;
                }
            }
        } catch (error) {
            console.warn('获取用户信息失败，使用默认ownerId:', error);
        }
        
        // 构建数据对象，确保字段与后端实体类匹配
        const formattedData = {
            brand: vehicleData.brand,
            model: vehicleData.model,
            color: vehicleData.color,
            licensePlate: vehicleData.license_plate,
            // 日期格式兼容ISO8601格式
            availableStart: vehicleData.available_start.toISOString(),
            availableEnd: vehicleData.available_end.toISOString(),
            // 使用实际登录用户的ID
            ownerId: ownerId
        };
        
        // 添加可选字段
        if (vehicleData.seat_count) formattedData.seatCount = vehicleData.seat_count;
        // 确保动力类型符合后端枚举要求
        if (vehicleData.power_type) {
            // 映射到后端支持的枚举值
            const powerTypeMap = {
                'gasoline': '汽油',
                'diesel': '柴油',
                'electric': '电动',
                'hybrid': '油电混动'
            };
            // 如果是英文，转换为中文；如果已经是中文，则直接使用
            formattedData.powerType = powerTypeMap[vehicleData.power_type.toLowerCase()] || vehicleData.power_type;
        }
        if (vehicleData.mileage) formattedData.mileage = vehicleData.mileage;
        if (vehicleData.daily_rate) formattedData.dailyRate = vehicleData.daily_rate;
        if (vehicleData.next_maintenance) formattedData.nextMaintenance = vehicleData.next_maintenance.toISOString();
        if (vehicleData.insurance_info) formattedData.insuranceInfo = vehicleData.insurance_info;
        // status字段转换为数字（0=可租用）
        formattedData.status = vehicleData.status === 'available' ? 0 : 1;
        
        // 添加调试信息，查看数据的完整内容
        console.log('原始表单数据:', vehicleData);
        console.log('准备发送到后端的数据:', formattedData);
        
        // 检查数据完整性
        const requiredFields = ['brand', 'model', 'color', 'licensePlate'];
        for (const field of requiredFields) {
            if (!formattedData[field] && formattedData[field] !== 0) {
                console.error(`必填字段缺失: ${field}`);
                throw new Error(`请填写完整的车辆信息，缺失字段: ${field}`);
            }
        }
        
        // 使用正确的API端点添加车辆 - 根据后端实际实现，应该是/api/vehicle/submit-mixed-data
        console.log('正在发送请求到后端...');
        const response = await fetch(`${API_BASE}/api/vehicle/submit-mixed-data`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${token}`
            },
            body: JSON.stringify(formattedData),
            credentials: 'include' // 确保包含cookie
        });
        
        console.log('请求已发送，等待响应...');
        
        // 检查响应状态
        if (!response.ok) {
            let errorMessage = `服务器响应错误: ${response.status}`;
            
            // 尝试获取错误详情
            try {
                const errorData = await response.json();
                console.log('错误详情:', errorData);
                errorMessage = errorData.message || errorMessage;
            } catch (e) {
                console.error('无法解析错误响应:', e);
            }
            
            throw new Error(errorMessage);
        }
        
        const result = await response.json();
        console.log('后端返回结果:', result);
        
        // 适配后端实际返回的格式
        if (result.status === 'success' || result.success) {
            return {
                success: true,
                data: {
                    vehicleInfoId: result.vehicleInfoId || result.data?.vehicleInfoId,
                    vehicleInstanceId: result.vehicleInstanceId || result.data?.vehicleInstanceId,
                    ...formattedData
                },
                message: result.message
            };
        } else {
            throw new Error(result.message || '添加车辆失败');
        }
    } catch (error) {
        console.error('API调用错误:', error);
        throw error;
    }
}

// 处理退出登录
function handleLogout() {
    if (confirm('确定要退出登录吗？')) {
        try {
            // 清除认证令牌
            clearAuthToken();
            // 重定向到登录页
            window.location.href = './login.html';
        } catch (error) {
            console.error('退出登录失败:', error);
            alert('退出登录失败，请稍后重试');
        }
    }
}

// 从Cookie获取认证令牌
function getAuthToken() {
    try {
        // 优先使用全局令牌管理工具，避免命名不一致
        if (window.AuthTokenManager && window.AuthTokenManager.getAuthToken) {
            return window.AuthTokenManager.getAuthToken();
        }
        if (window.utils && window.utils.cookie && window.utils.cookie.getAuthToken) {
            return window.utils.cookie.getAuthToken();
        }
        // 兜底：直接从cookie读取
        const cookie = document.cookie.split('; ').find(row => row.startsWith('auth_token='));
        return cookie ? cookie.split('=')[1] : null;
    } catch (error) {
        console.error('获取认证令牌失败:', error);
        return null;
    }
}

// 清除认证令牌
function clearAuthToken() {
    try {
        // 优先使用全局令牌管理工具
        if (window.AuthTokenManager && window.AuthTokenManager.removeAuthToken) {
            window.AuthTokenManager.removeAuthToken();
            return;
        }
        if (window.utils && window.utils.cookie && window.utils.cookie.removeAuthToken) {
            window.utils.cookie.removeAuthToken();
            return;
        }
        // 兜底：手动清除cookie
        document.cookie = 'auth_token=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
    } catch (error) {
        console.error('清除认证令牌失败:', error);
    }
}

/**
 * 格式化日期为ISO字符串格式
 * @param {Date} date - 日期对象
 * @returns {string} ISO格式的日期字符串
 */
function formatDate(date) {
    if (!date || !(date instanceof Date)) {
        console.warn('formatDate: 无效的日期对象');
        return null;
    }
    return date.toISOString();
}

/**
 * 解码系统令牌（支持系统自定义的下划线分隔格式）
 * @param {string} token - 认证令牌
 * @returns {Object|null} 解码后的用户信息对象或null
 */
function decodeToken(token) {
    try {
        if (!token) {
            console.warn('解码令牌失败：令牌为空');
            return null;
        }
        
        if (typeof token !== 'string') {
            console.warn('解码令牌失败：令牌不是字符串类型');
            return null;
        }
        
        // 优先尝试系统自定义的令牌格式（token_u10000_fa6d66791fd64b1598aee56f925b23eb_PX0xDL7xgNi2xSMJ_1758076557259）
        if (token.startsWith('token_')) {
            const parts = token.split('_');
            if (parts.length >= 5 && parts[1].startsWith('u')) {
                // 从令牌中提取用户ID（格式: token_u10000_...）
                const userId = parts[1].substring(1); // 移除前缀 'u'
                
                // 提取时间戳（令牌的最后一部分）
                const timestamp = parts[parts.length - 1];
                
                // 构造简单的用户信息对象
                const userInfo = {
                    userId: userId,
                    token: token,
                    timestamp: timestamp
                };
                
                console.log('成功解析系统格式令牌');
                return userInfo;
            }
        }
        
        // 尝试JWT格式（备用）
        if (token.indexOf('.') !== -1) {
            try {
                const parts = token.split('.');
                if (parts.length < 2 || !parts[1]) {
                    console.warn('JWT令牌没有有效载荷部分');
                    return null;
                }
                
                const base64Url = parts[1];
                const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
                const paddedBase64 = base64 + '===='.substr(0, (4 - base64.length % 4) % 4);
                const jsonPayload = decodeURIComponent(atob(paddedBase64).split('').map(function(c) {
                    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
                }).join(''));
                
                const payload = JSON.parse(jsonPayload);
                return payload;
            } catch (e) {
                console.warn('JWT令牌解析错误', e);
            }
        }
        
        // 令牌格式未知，但至少返回一个包含令牌本身的对象，避免完全失败
        console.warn('令牌格式未知，但将继续使用');
        return {
            token: token,
            userId: null
        };
    } catch (error) {
        console.warn('解码令牌过程中发生错误', error);
        // 即使出错也不返回null，而是返回包含令牌的对象，确保用户可以继续操作
        return {
            token: token,
            userId: null
        };
    }
}